# -*- coding: utf-8 -*-
# author yzs
# date 2019-01-01
#
# 链表回文
# Description
# 判断一个单向链是否为回文结构。自定义链表数据结构，要求时间复杂度O(n),额外空间复杂度为O(1).
# Input
# 输入的每一行的值用空格隔开，第一个值为节点个数，后面为每一个节点值
# Output
# 是回文则输出true，不是则输出false，一行表示一个链表的结果
# Sample Input 1
# 3 1 2 1
# 4 1 2 2 1
# 3 3 5 3
# 6 a b c d c a
# Sample Output 1
# true
# true
# true
# false
# 解题思路：题目要求为单向链，可使用快慢指针法
# （1）设置一个块指针和一个慢指针，快指针一次走两步，慢指针一次走一步（慢），
#      当快指针下一步为null的时候说明慢指针已经走了一半，这就可以找到中间节点。
# （2）反转中间链表后面的指针，
# （3）从头尾向中间扫描，对比每个元素是否相等，如果都相等，则是回文数，否则不是回文数。


class Node(object):
    def __init__(self, data, p=0):
        self.data = data
        self.next = p


class LinkList(object):
    def __init__(self):
        self.head = 0

    def init(self, data):
        if data[0] is not '-1':
            self.head = Node(data[0])
        p = self.head
        data_len = len(data)
        for i in range(1, data_len):
            if data[i] == '-1':
                break
            else:
                p.next = Node(data[i])
                p = p.next
        p.next = None


def check_palindrome(head):
        if head is None or head.next is None:
            return True
        slow = head
        fast = head
        while fast.next is not None and fast.next.next is not None:
            slow = slow.next
            fast = fast.next.next
        last = slow.next
        pre = head
        while last.next is not None:
            tmp = last.next
            last.next = tmp.next
            tmp.next = slow.next
            slow.next = tmp
        while slow.next is not None:
            slow = slow.next
            if pre.data != slow.data:
                return False
            pre = pre.next
        return True


while True:
    try:
        data = list(input().strip().split())
        num, data = int(data[0]), data[1:int(data[0]) + 1]
        link_list = LinkList()
        link_list.init(data)
        if check_palindrome(link_list.head):
            print("true")
        else:
            print("false")
    except EOFError:
        break
